home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / PIL / PcfFontFile.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  6.4 KB  |  201 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import Image
  5. import FontFile
  6. import string
  7. PCF_MAGIC = 1885562369
  8. PCF_PROPERTIES = 1
  9. PCF_ACCELERATORS = 2
  10. PCF_METRICS = 4
  11. PCF_BITMAPS = 8
  12. PCF_INK_METRICS = 16
  13. PCF_BDF_ENCODINGS = 32
  14. PCF_SWIDTHS = 64
  15. PCF_GLYPH_NAMES = 128
  16. PCF_BDF_ACCELERATORS = 256
  17. BYTES_PER_ROW = [
  18.     (lambda bits: bits + 7 >> 3),
  19.     (lambda bits: bits + 15 >> 3 & -2),
  20.     (lambda bits: bits + 31 >> 3 & -4),
  21.     (lambda bits: bits + 63 >> 3 & -8)]
  22.  
  23. def l16(c):
  24.     return ord(c[0]) + (ord(c[1]) << 8)
  25.  
  26.  
  27. def l32(c):
  28.     return ord(c[0]) + (ord(c[1]) << 8) + (ord(c[2]) << 16) + (ord(c[3]) << 24)
  29.  
  30.  
  31. def b16(c):
  32.     return ord(c[1]) + (ord(c[0]) << 8)
  33.  
  34.  
  35. def b32(c):
  36.     return ord(c[3]) + (ord(c[2]) << 8) + (ord(c[1]) << 16) + (ord(c[0]) << 24)
  37.  
  38.  
  39. def sz(s, o):
  40.     return s[o:string.index(s, '\x00', o)]
  41.  
  42.  
  43. class PcfFontFile(FontFile.FontFile):
  44.     name = 'name'
  45.     
  46.     def __init__(self, fp):
  47.         magic = l32(fp.read(4))
  48.         if magic != PCF_MAGIC:
  49.             raise SyntaxError, 'not a PCF file'
  50.         
  51.         FontFile.FontFile.__init__(self)
  52.         count = l32(fp.read(4))
  53.         self.toc = { }
  54.         for i in range(count):
  55.             type = l32(fp.read(4))
  56.             self.toc[type] = (l32(fp.read(4)), l32(fp.read(4)), l32(fp.read(4)))
  57.         
  58.         self.fp = fp
  59.         self.info = self._load_properties()
  60.         metrics = self._load_metrics()
  61.         bitmaps = self._load_bitmaps(metrics)
  62.         encoding = self._load_encoding()
  63.         for ch in range(256):
  64.             ix = encoding[ch]
  65.             if ix is not None:
  66.                 (x, y, l, r, w, a, d, f) = metrics[ix]
  67.                 glyph = ((w, 0), (l, d - y, x + l, d), (0, 0, x, y), bitmaps[ix])
  68.                 self.glyph[ch] = glyph
  69.                 continue
  70.         
  71.  
  72.     
  73.     def _getformat(self, tag):
  74.         (format, size, offset) = self.toc[tag]
  75.         fp = self.fp
  76.         fp.seek(offset)
  77.         format = l32(fp.read(4))
  78.         if format & 4:
  79.             i16 = b16
  80.             i32 = b32
  81.         else:
  82.             i16 = l16
  83.             i32 = l32
  84.         return (fp, format, i16, i32)
  85.  
  86.     
  87.     def _load_properties(self):
  88.         properties = { }
  89.         (fp, format, i16, i32) = self._getformat(PCF_PROPERTIES)
  90.         nprops = i32(fp.read(4))
  91.         p = []
  92.         for i in range(nprops):
  93.             p.append((i32(fp.read(4)), ord(fp.read(1)), i32(fp.read(4))))
  94.         
  95.         if nprops & 3:
  96.             fp.seek(4 - (nprops & 3), 1)
  97.         
  98.         data = fp.read(i32(fp.read(4)))
  99.         for k, s, v in p:
  100.             k = sz(data, k)
  101.             if s:
  102.                 v = sz(data, v)
  103.             
  104.             properties[k] = v
  105.         
  106.         return properties
  107.  
  108.     
  109.     def _load_metrics(self):
  110.         metrics = []
  111.         (fp, format, i16, i32) = self._getformat(PCF_METRICS)
  112.         append = metrics.append
  113.         if format & 65280 == 256:
  114.             for i in range(i16(fp.read(2))):
  115.                 left = ord(fp.read(1)) - 128
  116.                 right = ord(fp.read(1)) - 128
  117.                 width = ord(fp.read(1)) - 128
  118.                 ascent = ord(fp.read(1)) - 128
  119.                 descent = ord(fp.read(1)) - 128
  120.                 xsize = right - left
  121.                 ysize = ascent + descent
  122.                 append((xsize, ysize, left, right, width, ascent, descent, 0))
  123.             
  124.         else:
  125.             for i in range(i32(fp.read(4))):
  126.                 left = i16(fp.read(2))
  127.                 right = i16(fp.read(2))
  128.                 width = i16(fp.read(2))
  129.                 ascent = i16(fp.read(2))
  130.                 descent = i16(fp.read(2))
  131.                 attributes = i16(fp.read(2))
  132.                 xsize = right - left
  133.                 ysize = ascent + descent
  134.                 append((xsize, ysize, left, right, width, ascent, descent, attributes))
  135.             
  136.         return metrics
  137.  
  138.     
  139.     def _load_bitmaps(self, metrics):
  140.         bitmaps = []
  141.         (fp, format, i16, i32) = self._getformat(PCF_BITMAPS)
  142.         nbitmaps = i32(fp.read(4))
  143.         if nbitmaps != len(metrics):
  144.             raise IOError, 'Wrong number of bitmaps'
  145.         
  146.         offsets = []
  147.         for i in range(nbitmaps):
  148.             offsets.append(i32(fp.read(4)))
  149.         
  150.         bitmapSizes = []
  151.         for i in range(4):
  152.             bitmapSizes.append(i32(fp.read(4)))
  153.         
  154.         byteorder = format & 4
  155.         bitorder = format & 8
  156.         padindex = format & 3
  157.         bitmapsize = bitmapSizes[padindex]
  158.         offsets.append(bitmapsize)
  159.         data = fp.read(bitmapsize)
  160.         pad = BYTES_PER_ROW[padindex]
  161.         mode = '1;R'
  162.         if bitorder:
  163.             mode = '1'
  164.         
  165.         for i in range(nbitmaps):
  166.             (x, y, l, r, w, a, d, f) = metrics[i]
  167.             b = offsets[i]
  168.             e = offsets[i + 1]
  169.             bitmaps.append(Image.fromstring('1', (x, y), data[b:e], 'raw', mode, pad(x)))
  170.         
  171.         return bitmaps
  172.  
  173.     
  174.     def _load_encoding(self):
  175.         encoding = [
  176.             None] * 256
  177.         (fp, format, i16, i32) = self._getformat(PCF_BDF_ENCODINGS)
  178.         firstCol = i16(fp.read(2))
  179.         lastCol = i16(fp.read(2))
  180.         firstRow = i16(fp.read(2))
  181.         lastRow = i16(fp.read(2))
  182.         default = i16(fp.read(2))
  183.         nencoding = ((lastCol - firstCol) + 1) * ((lastRow - firstRow) + 1)
  184.         for i in range(nencoding):
  185.             encodingOffset = i16(fp.read(2))
  186.             if encodingOffset != 65535:
  187.                 
  188.                 try:
  189.                     encoding[i + firstCol] = encodingOffset
  190.                 except IndexError:
  191.                     break
  192.                 except:
  193.                     None<EXCEPTION MATCH>IndexError
  194.                 
  195.  
  196.             None<EXCEPTION MATCH>IndexError
  197.         
  198.         return encoding
  199.  
  200.  
  201.